import { toNumber } from 'lodash-es'

/**
 *
 * @param component 需要注册的组件
 * @param alias 组件别名
 * @returns any
 */
export const withInstall = <T>(component: T, alias?: string) => {
  const comp = component as any
  comp.install = (app: any) => {
    app.component(comp.name || comp.displayName, component)
    if (alias) {
      app.config.globalProperties[alias] = component
    }
  }
  return component as T & Plugin
}

/**
 * @param str 需要转下划线的驼峰字符串
 * @returns 字符串下划线
 */
export const humpToUnderline = (str: string): string => {
  return str.replace(/([A-Z])/g, '-$1').toLowerCase()
}

/**
 * @param str 需要转驼峰的下划线字符串
 * @returns 字符串驼峰
 */
export const underlineToHump = (str: string): string => {
  if (!str) return ''
  return str.replace(/\-(\w)/g, (_, letter: string) => {
    return letter.toUpperCase()
  })
}

/**
 * 驼峰转横杠
 */
export const humpToDash = (str: string): string => {
  return str.replace(/([A-Z])/g, '-$1').toLowerCase()
}

export const setCssVar = (prop: string, val: any, dom = document.documentElement) => {
  dom.style.setProperty(prop, val)
}

/**
 * 查找数组对象的某个下标
 * @param {Array} ary 查找的数组
 * @param {Functon} fn 判断的方法
 */
// eslint-disable-next-line
export const findIndex = <T = Recordable>(ary: Array<T>, fn: Fn): number => {
  if (ary.findIndex) {
    return ary.findIndex(fn)
  }
  let index = -1
  ary.some((item: T, i: number, ary: Array<T>) => {
    const ret: T = fn(item, i, ary)
    if (ret) {
      index = i
      return ret
    }
  })
  return index
}

export const trim = (str: string) => {
  return str.replace(/(^\s*)|(\s*$)/g, '')
}

/**
 * @param {Date | number | string} time 需要转换的时间
 * @param {String} fmt 需要转换的格式 如 yyyy-MM-dd、yyyy-MM-dd HH:mm:ss
 */
export function formatTime(time: Date | number | string, fmt: string) {
  if (!time) return ''
  else {
    const date = new Date(time)
    const o = {
      'M+': date.getMonth() + 1,
      'd+': date.getDate(),
      'H+': date.getHours(),
      'm+': date.getMinutes(),
      's+': date.getSeconds(),
      'q+': Math.floor((date.getMonth() + 3) / 3),
      S: date.getMilliseconds()
    }
    if (/(y+)/.test(fmt)) {
      fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length))
    }
    for (const k in o) {
      if (new RegExp('(' + k + ')').test(fmt)) {
        fmt = fmt.replace(
          RegExp.$1,
          RegExp.$1.length === 1 ? o[k] : ('00' + o[k]).substr(('' + o[k]).length)
        )
      }
    }
    return fmt
  }
}

/**
 * 生成随机字符串
 */
export function toAnyString() {
  const str: string = 'xxxxx-xxxxx-4xxxx-yxxxx-xxxxx'.replace(/[xy]/g, (c: string) => {
    const r: number = (Math.random() * 16) | 0
    const v: number = c === 'x' ? r : (r & 0x3) | 0x8
    return v.toString()
  })
  return str
}

/**
 * 首字母大写
 */
export function firstUpperCase(str: string) {
  return str.toLowerCase().replace(/( |^)[a-z]/g, (L) => L.toUpperCase())
}

export const generateUUID = () => {
  if (typeof crypto === 'object') {
    if (typeof crypto.randomUUID === 'function') {
      return crypto.randomUUID()
    }
    if (typeof crypto.getRandomValues === 'function' && typeof Uint8Array === 'function') {
      const callback = (c: any) => {
        const num = Number(c)
        return (num ^ (crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (num / 4)))).toString(
          16
        )
      }
      return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, callback)
    }
  }
  let timestamp = new Date().getTime()
  let performanceNow =
    (typeof performance !== 'undefined' && performance.now && performance.now() * 1000) || 0
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    let random = Math.random() * 16
    if (timestamp > 0) {
      random = (timestamp + random) % 16 | 0
      timestamp = Math.floor(timestamp / 16)
    } else {
      random = (performanceNow + random) % 16 | 0
      performanceNow = Math.floor(performanceNow / 16)
    }
    return (c === 'x' ? random : (random & 0x3) | 0x8).toString(16)
  })
}

/**
 * element plus 的文件大小 Formatter 实现
 *
 * @param row 行数据
 * @param column 字段
 * @param cellValue 字段值
 */
// @ts-ignore
export const fileSizeFormatter = (row, column, cellValue) => {
  const fileSize = cellValue
  const unitArr = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
  const srcSize = parseFloat(fileSize)
  const index = Math.floor(Math.log(srcSize) / Math.log(1024))
  const size = srcSize / Math.pow(1024, index)
  const sizeStr = size.toFixed(2) //保留的小数位数
  return sizeStr + ' ' + unitArr[index]
}

/**
 * 将值复制到目标对象，且以目标对象属性为准，例：target: {a:1} source:{a:2,b:3} 结果为：{a:2}
 * @param target 目标对象
 * @param source 源对象
 */
export const copyValueToTarget = (target: any, source: any) => {
  const newObj = Object.assign({}, target, source)
  // 删除多余属性
  Object.keys(newObj).forEach((key) => {
    // 如果不是target中的属性则删除
    if (Object.keys(target).indexOf(key) === -1) {
      delete newObj[key]
    }
  })
  // 更新目标对象值
  Object.assign(target, newObj)
}

/**
 * 获取链接的参数值
 * @param key 参数键名
 * @param urlStr 链接地址，默认为当前浏览器的地址
 */
export const getUrlValue = (key: string, urlStr: string = location.href): string => {
  if (!urlStr || !key) return ''
  const url = new URL(decodeURIComponent(urlStr))
  return url.searchParams.get(key) ?? ''
}

/**
 * 获取链接的参数值（值类型）
 * @param key 参数键名
 * @param urlStr 链接地址，默认为当前浏览器的地址
 */
export const getUrlNumberValue = (key: string, urlStr: string = location.href): number => {
  return toNumber(getUrlValue(key, urlStr))
}

/**
 * 构建排序字段
 * @param prop 字段名称
 * @param order 顺序
 */
export const buildSortingField = ({ prop, order }) => {
  return { field: prop, order: order === 'ascending' ? 'asc' : 'desc' }
}

// ========== NumberUtils 数字方法 ==========

/**
 * 数组求和
 *
 * @param values 数字数组
 * @return 求和结果，默认为 0
 */
export const getSumValue = (values: number[]): number => {
  return values.reduce((prev, curr) => {
    const value = Number(curr)
    if (!Number.isNaN(value)) {
      return prev + curr
    } else {
      return prev
    }
  }, 0)
}

// ========== 通用金额方法 ==========

/**
 * 将一个整数转换为分数保留两位小数
 * @param num
 */
export const formatToFraction = (num: number | string | undefined): string => {
  if (typeof num === 'undefined') return '0.00'
  const parsedNumber = typeof num === 'string' ? parseFloat(num) : num
  return (parsedNumber / 100.0).toFixed(2)
}

/**
 * 将一个数转换为 1.00 这样
 * 数据呈现的时候使用
 *
 * @param num 整数
 */
// TODO @芋艿：看看怎么融合掉
export const floatToFixed2 = (num: number | string | undefined): string => {
  let str = '0.00'
  if (typeof num === 'undefined') {
    return str
  }
  const f = formatToFraction(num)
  const decimalPart = f.toString().split('.')[1]
  const len = decimalPart ? decimalPart.length : 0
  switch (len) {
    case 0:
      str = f.toString() + '.00'
      break
    case 1:
      str = f.toString() + '0'
      break
    case 2:
      str = f.toString()
      break
  }
  return str
}

/**
 * 将一个分数转换为整数
 * @param num
 */
// TODO @芋艿：看看怎么融合掉
export const convertToInteger = (num: number | string | undefined): number => {
  if (typeof num === 'undefined') return 0
  const parsedNumber = typeof num === 'string' ? parseFloat(num) : num
  // TODO 分转元后还有小数则四舍五入
  return Math.round(parsedNumber * 100)
}

/**
 * 元转分
 */
export const yuanToFen = (amount: string | number): number => {
  return convertToInteger(amount)
}

/**
 * 分转元
 */
export const fenToYuan = (price: string | number): string => {
  return formatToFraction(price)
}

/**
 * 计算环比
 *
 * @param value 当前数值
 * @param reference 对比数值
 */
export const calculateRelativeRate = (value?: number, reference?: number) => {
  // 防止除0
  if (!reference) return 0

  return ((100 * ((value || 0) - reference)) / reference).toFixed(0)
}

// ========== ERP 专属方法 ==========

const ERP_COUNT_DIGIT = 3
const ERP_PRICE_DIGIT = 2

/**
 * 【ERP】格式化 Input 数字
 *
 * 例如说：库存数量
 *
 * @param num 数量
 * @package digit 保留的小数位数
 * @return 格式化后的数量
 */
export const erpNumberFormatter = (num: number | string | undefined, digit: number) => {
  if (num == null) {
    return ''
  }
  if (typeof num === 'string') {
    num = parseFloat(num)
  }
  // 如果非 number，则直接返回空串
  if (isNaN(num)) {
    return ''
  }
  return num.toFixed(digit)
}

/**
 * 【ERP】格式化数量，保留三位小数
 *
 * 例如说：库存数量
 *
 * @param num 数量
 * @return 格式化后的数量
 */
export const erpCountInputFormatter = (num: number | string | undefined) => {
  return erpNumberFormatter(num, ERP_COUNT_DIGIT)
}

// noinspection JSCommentMatchesSignature
/**
 * 【ERP】格式化数量，保留三位小数
 *
 * @param cellValue 数量
 * @return 格式化后的数量
 */
export const erpCountTableColumnFormatter = (_, __, cellValue: any, ___) => {
  return erpNumberFormatter(cellValue, ERP_COUNT_DIGIT)
}

/**
 * 【ERP】格式化金额，保留二位小数
 *
 * 例如说：库存数量
 *
 * @param num 数量
 * @return 格式化后的数量
 */
export const erpPriceInputFormatter = (num: number | string | undefined) => {
  return erpNumberFormatter(num, ERP_PRICE_DIGIT)
}

// noinspection JSCommentMatchesSignature
/**
 * 【ERP】格式化金额，保留二位小数
 *
 * @param cellValue 数量
 * @return 格式化后的数量
 */
export const erpPriceTableColumnFormatter = (_, __, cellValue: any, ___) => {
  return erpNumberFormatter(cellValue, ERP_PRICE_DIGIT)
}

/**
 * 【ERP】价格计算，四舍五入保留两位小数
 *
 * @param price 价格
 * @param count 数量
 * @return 总价格。如果有任一为空，则返回 undefined
 */
export const erpPriceMultiply = (price: number, count: number) => {
  if (price == null || count == null) {
    return undefined
  }
  return parseFloat((price * count).toFixed(ERP_PRICE_DIGIT))
}

/**
 * 【ERP】百分比计算，四舍五入保留两位小数
 *
 * 如果 total 为 0，则返回 0
 *
 * @param value 当前值
 * @param total 总值
 */
export const erpCalculatePercentage = (value: number, total: number) => {
  if (total === 0) return 0
  return ((value / total) * 100).toFixed(2)
}

/**
 * 适配 echarts map 的地名
 *
 * @param areaName 地区名称
 */
export const areaReplace = (areaName: string) => {
  if (!areaName) {
    return areaName
  }
  return areaName
    .replace('维吾尔自治区', '')
    .replace('壮族自治区', '')
    .replace('回族自治区', '')
    .replace('自治区', '')
    .replace('省', '')
}

export const clearAllCookies = () => {
  const cookies = document.cookie.split(";");

  for (let i = 0; i < cookies.length; i++) {
    const cookie = cookies[i];
    const eqPos = cookie.indexOf("=");
    const name = eqPos > -1 ? cookie.substr(0, eqPos) : cookie;
    document.cookie = name + "=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/";
  }
}
/**
 * 转换字符串的字符集编码
 * @param str 需要转换的字符串
 * @param charset 字符集编码
 */
export function decodeStringToCharset(str: string, charset = 'UTF-8') {
  const encoder = new TextEncoder();
  const decoder = new TextDecoder(charset);
  return decoder.decode(encoder.encode(str));
}
/**
 * json转为表格
 * */
function isInteger(n) {
  return Number.isInteger(n);
}

export function JsonforData(jsonObj) {
  const data = { root: {} }
  data.root = jsonObj
  jsonObj = data
  return jsonToTableData1(data)
}

export function jsonToTableData1(jsonObj) {
  return Object.entries(jsonObj).map(([key, value]) => {
    const keyType = typeof value;
    let typeStr = '';
    if (keyType == 'object') {
      typeStr = 'object';
      let children = []
      if (JSON.stringify(value) === '{}' || value === null) {
        value = ''
      } else {
        children = jsonToTableData1(value)
        value = ''
      }
      value = ''
      return {
        id: guid(),
        keyName: key,
        keyValue: value,
        keyType: typeStr,
        children: children
      };
    } else {
      if (keyType === 'number') {
        typeStr = isInteger(value) ? 'integer' : 'number';
      } else if (keyType === 'boolean') {
        typeStr = 'boolean';
      } else if (keyType === 'string') {
        typeStr = 'string';
      } else {
        typeStr = keyType; // 其他类型保持原样
      }
      return {
        id: guid(),
        keyName: key,
        keyValue: value,
        keyType: typeStr,
      };
    }
  });
}
export function jsonToTableData(jsonObj) {
  return Object.entries(jsonObj).map(([key, value]) => {
    let keyValue = value;
    let typeStr = '';

    if (Array.isArray(value)) {
      // 如果值是数组，则将其转换为 JSON 字符串
      keyValue = JSON.stringify(value, null, 2); // 使用缩进使 JSON 更易读
      typeStr = 'array';
    } else if (typeof value === 'object' && value !== null) {
      // 如果值是对象且不是 null，则将其转换为 JSON 字符串
      keyValue = JSON.stringify(value, null, 2); // 使用缩进使 JSON 更易读
      typeStr = 'object';
    } else {
      // 其他基本类型
      if (typeof value === 'number') {
        typeStr = isInteger(value) ? 'integer' : 'number';
      } else if (typeof value === 'boolean') {
        typeStr = 'boolean';
      } else if (typeof value === 'string') {
        typeStr = 'string';
      } else {
        typeStr = typeof value; // 其他类型保持原样
      }
    }

    return {
      id: guid(),
      keyName: key,
      keyValue: keyValue,
      keyType: typeStr,
    };
  });
}

export const guid = () => {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(
    /[xy]/g,
    function (c) {
      const r = (Math.random() * 16) | 0,
        v = c == 'x' ? r : (r & 0x3) | 0x8
      return v.toString(16)
    }
  )
}

export function DataforJson(tableData) {
  if (tableData) {
    if (tableData[0].keyName == "root") {
      if (tableData[0].children) {
        tableData = tableData[0].children
      } else {
        tableData = []
      }
    }
  }
  else {
    tableData = []
  }
  return tableDataToJson1(tableData)
}
export function tableDataToJson1(tableData) {
  return tableData.reduce((acc, { keyName, keyValue, keyType, children }) => {
    let value;
    if (keyType == 'array') {
      value = []
      if (children) {
        children.forEach((item) => {
          if (item.children) {
            const child = tableDataToJson1(item.children)
            value.push(child)
          } else {
            value.push(item.keyValue)
          }
        })
      } else {
        value = []
      }
      acc[keyName] = value;
    } else {
      if (keyType == 'boolean') {
        value = !!keyValue
      } else if (keyType == 'number' || keyType == 'integer') {
        value = keyValue * 1
      } else if (keyType == 'object') {
        if (children) {
          const child = tableDataToJson1(children)
          value = { ...child }
        } else {
          value = {}
        }
      } else {
        value = keyValue
      }
      acc[keyName] = value;
    }
    return acc;
  }, {});
}
/**
 * 表格数据转为json
 * */
export function tableDataToJson(tableData) {
  return tableData.reduce((acc, { keyName, keyValue, keyType, children }) => {
    if (!keyName) {
      // 如果 keyName 为空，则跳过该条目
      return acc;
    }

    let value;

    if (keyType === 'array') {
      if (Array.isArray(keyValue)) {
        // 如果 keyValue 已经是数组，则直接使用
        value = keyValue;
      } else {
        try {
          value = keyValue ? JSON.parse(keyValue) : []; // 尝试将字符串解析为数组
          if (!Array.isArray(value)) {
            console.error(`Parsed value is not an array: ${keyValue}`);
            value = []; // 如果解析结果不是数组，则设置为空数组
          }
        } catch (e) {
          console.error(`Failed to parse array string: ${keyValue}`, e);
          value = []; // 如果解析失败，则设置为空数组
        }
      }
    } else if (keyType === 'boolean') {
      value = keyValue ? keyValue.toLowerCase() === 'true' : false; // 将字符串 'true' 或 'false' 转换为布尔值
    } else if (keyType === 'number' || keyType === 'integer') {
      value = Number(keyValue); // 将字符串转换为数字
    } else if (keyType === 'object' || isJsonString(keyValue)) {
      try {
        value = keyValue ? JSON.parse(keyValue) : {}; // 尝试将字符串解析为对象
      } catch (e) {
        console.error(`Failed to parse object or array string: ${keyValue}`, e);
        value = {}; // 如果解析失败，则设置为空对象
      }
    } else {
      value = keyValue; // 其他类型保持原样
    }

    acc[keyName] = value;
    return acc;
  }, {});
}
// 辅助函数：检查一个字符串是否是有效的 JSON
function isJsonString(str) {
  try {
    const parsed = JSON.parse(str);
    return (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) || Array.isArray(parsed);
  } catch (e) {
    return false;
  }
}
export function evnjsonToTableData(jsonObj) {
  return Object.entries(jsonObj).map(([key, value]) => {
    return {
      varName: key,
      localValue: value
    };
  });
}

export function evntableDataToJson(tableData) {
  return tableData.reduce((acc, { varName, localValue }) => {
    acc[varName] = localValue;
    return acc;
  }, {});
}

/**
 * @description 是够有滚动条
 */
export const hasScrollbar = () => {
  return document.body.scrollHeight > (window.innerHeight || document.documentElement.clientHeight)
}

/**
 * @description 获得滚动条的宽度
 */
export const getScrollbarWidth = () => {
  const scrollDiv = document.createElement('div')

  scrollDiv.style.cssText = 'width: 99px; height: 99px; overflow: scroll; position: absolute; top: -9999px;'
  document.body.appendChild(scrollDiv)

  const scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth

  document.body.removeChild(scrollDiv)

  return scrollbarWidth
}

export function jsonToColonFormat(jsonObj) {
  if (typeof jsonObj !== 'object' || jsonObj === null) {
    throw new Error('Input must be a JSON object');
  }

  let result = '';

  // 遍历对象的第一层属性
  for (const key in jsonObj) {
    if (jsonObj.hasOwnProperty(key)) {
      const value = jsonObj[key];

      // 定义一个函数来生成不带双引号的 JSON 字符串
      function stringifyWithoutQuotes(obj) {
        if (obj === null) {
          return 'null';
        }
        if (typeof obj === 'object' && obj !== null) {
          if (Array.isArray(obj)) {
            return `[${obj.map(item => stringifyWithoutQuotes(item)).join(',')}]`;
          } else {
            const properties = [];
            for (const k in obj) {
              if (obj.hasOwnProperty(k)) {
                const v = obj[k];
                properties.push(`${k}:${stringifyWithoutQuotes(v)}`);
              }
            }
            return `{${properties.join(',')}}`;
          }
        } else if (typeof obj === 'string') {
          return JSON.stringify(obj); // 对字符串进行转义
        } else {
          return obj.toString();
        }
      }

      // 如果值是对象或数组，使用自定义函数生成字符串
      if (typeof value === 'object' && value !== null) {
        result += `${key}:${stringifyWithoutQuotes(value)}\n`;
      } else {
        // 处理基本数据类型
        if (typeof value === 'string') {
          // 对字符串进行转义，确保输出的字符串是安全的
          result += `${key}:${JSON.stringify(value)}\n`;
        } else if (typeof value === 'number' || typeof value === 'boolean' || value === null) {
          // 直接输出数字、布尔值和 null
          result += `${key}:${value}\n`;
        }
      }
    }
  }

  return result.trim();
}

export function colonFormatToJson(str) {
  const result = {};

  // 使用换行符分割字符串以提取键值对
  const keyValuePairs = str.split('\n');

  // 遍历所有的键值对
  keyValuePairs.forEach(pair => {
    // 去除空白字符
    pair = pair.trim();

    // 如果键值对为空，则跳过
    if (!pair) {
      return;
    }

    // 提取键和值
    const parts = pair.split(':').map(part => part.trim());
    const key = parts[0]; // 原始键
    const rawValue = parts.slice(1).join(':').trim(); // 重新组合可能带有冒号的值

    // 尝试将值转换为正确的数据类型
    const value = parseJsonValue(rawValue);

    // 将键值对添加到结果对象中
    result[key] = value;
  });

  return result;
}

function parseJsonValue(valueStr) {
  if (valueStr.startsWith('{') && valueStr.endsWith('}')) {
    return parseJsonObject(valueStr);
  } else if (valueStr.startsWith('[') && valueStr.endsWith(']')) {
    return parseJsonArray(valueStr);
  } else if (valueStr === 'true' || valueStr === 'false') {
    return valueStr === 'true';
  } else if (valueStr === 'null') {
    return null;
  } else if (!isNaN(Number(valueStr))) {
    return Number(valueStr);
  } else if (valueStr.startsWith('"') && valueStr.endsWith('"') ||
    valueStr.startsWith("'") && valueStr.endsWith("'") ||
    valueStr.startsWith("`") && valueStr.endsWith("`")) {
    return valueStr.slice(1, -1);
  } else {
    return valueStr; // 确保字符串有引号
  }
}

function parseJsonObject(jsonStr) {
  const result = {};
  const content = jsonStr.slice(1, -1).trim();

  if (!content) {
    return result;
  }

  const pairs = content.split(',');
  pairs.forEach(pair => {
    const parts = pair.split(':').map(part => part.trim());
    const key = parts[0]; // 原始键
    const rawValue = parts.slice(1).join(':').trim();
    const value = parseJsonValue(rawValue);

    result[key] = value;
  });

  return result;
}

function parseJsonArray(jsonStr) {
  // 将所有未加引号的键转换为带双引号的形式
  const strWithQuotes = jsonStr.replace(/(\w+):/g, '"$1":');
  
  try {
    // 使用 JSON.parse 安全地解析 JSON 字符串
    const result = JSON.parse(strWithQuotes);
    
    // 确保返回的是一个数组
    if (Array.isArray(result)) {
      return result;
    } else {
      throw new Error("Provided JSON string is not an array.");
    }
  } catch (error) {
    // 如果 JSON 解析出错，抛出错误或者返回空数组
    console.error('Failed to parse JSON array:', error);
    return [];
  }
}

